/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_matmul_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>
#include <vector>

#include "test/matmul/fixture.h"
#include "test/types/kernel_data_types.h"
#include "test/types/to_gtest_types.h"

using DataTypeList = sycldnn::types::KernelDataTypes;
using GTestTypeList = sycldnn::types::ToGTestTypes<DataTypeList>::type;

template <typename DataType>
using MatmulBatch1Beta0TrueFalse = MatmulFixture<DataType, true, false>;
TYPED_TEST_SUITE(MatmulBatch1Beta0TrueFalse, GTestTypeList);
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK14xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      163086., 164374., 165662., 166950., 168238., 169526., 170814., 172102.,
      173390., 174678., 175966., 177254., 178542., 179830., 164374., 165676.,
      166978., 168280., 169582., 170884., 172186., 173488., 174790., 176092.,
      177394., 178696., 179998., 181300., 165662., 166978., 168294., 169610.,
      170926., 172242., 173558., 174874., 176190., 177506., 178822., 180138.,
      181454., 182770., 166950., 168280., 169610., 170940., 172270., 173600.,
      174930., 176260., 177590., 178920., 180250., 181580., 182910., 184240.,
      168238., 169582., 170926., 172270., 173614., 174958., 176302., 177646.,
      178990., 180334., 181678., 183022., 184366., 185710., 169526., 170884.,
      172242., 173600., 174958., 176316., 177674., 179032., 180390., 181748.,
      183106., 184464., 185822., 187180., 170814., 172186., 173558., 174930.,
      176302., 177674., 179046., 180418., 181790., 183162., 184534., 185906.,
      187278., 188650., 172102., 173488., 174874., 176260., 177646., 179032.,
      180418., 181804., 183190., 184576., 185962., 187348., 188734., 190120.,
      173390., 174790., 176190., 177590., 178990., 180390., 181790., 183190.,
      184590., 185990., 187390., 188790., 190190., 191590., 174678., 176092.,
      177506., 178920., 180334., 181748., 183162., 184576., 185990., 187404.,
      188818., 190232., 191646., 193060., 175966., 177394., 178822., 180250.,
      181678., 183106., 184534., 185962., 187390., 188818., 190246., 191674.,
      193102., 194530., 177254., 178696., 180138., 181580., 183022., 184464.,
      185906., 187348., 188790., 190232., 191674., 193116., 194558., 196000.,
      178542., 179998., 181454., 182910., 184366., 185822., 187278., 188734.,
      190190., 191646., 193102., 194558., 196014., 197470., 179830., 181300.,
      182770., 184240., 185710., 187180., 188650., 190120., 191590., 193060.,
      194530., 196000., 197470., 198940.};
  const int batches = 1;
  const int m = 14;
  const int k = 14;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK14xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      174643., 175931., 177219., 178507., 179795., 181083., 182371., 183659.,
      184947., 186235., 187523., 188811., 190099., 191387., 192675., 176022.,
      177324., 178626., 179928., 181230., 182532., 183834., 185136., 186438.,
      187740., 189042., 190344., 191646., 192948., 194250., 177401., 178717.,
      180033., 181349., 182665., 183981., 185297., 186613., 187929., 189245.,
      190561., 191877., 193193., 194509., 195825., 178780., 180110., 181440.,
      182770., 184100., 185430., 186760., 188090., 189420., 190750., 192080.,
      193410., 194740., 196070., 197400., 180159., 181503., 182847., 184191.,
      185535., 186879., 188223., 189567., 190911., 192255., 193599., 194943.,
      196287., 197631., 198975., 181538., 182896., 184254., 185612., 186970.,
      188328., 189686., 191044., 192402., 193760., 195118., 196476., 197834.,
      199192., 200550., 182917., 184289., 185661., 187033., 188405., 189777.,
      191149., 192521., 193893., 195265., 196637., 198009., 199381., 200753.,
      202125., 184296., 185682., 187068., 188454., 189840., 191226., 192612.,
      193998., 195384., 196770., 198156., 199542., 200928., 202314., 203700.,
      185675., 187075., 188475., 189875., 191275., 192675., 194075., 195475.,
      196875., 198275., 199675., 201075., 202475., 203875., 205275., 187054.,
      188468., 189882., 191296., 192710., 194124., 195538., 196952., 198366.,
      199780., 201194., 202608., 204022., 205436., 206850., 188433., 189861.,
      191289., 192717., 194145., 195573., 197001., 198429., 199857., 201285.,
      202713., 204141., 205569., 206997., 208425., 189812., 191254., 192696.,
      194138., 195580., 197022., 198464., 199906., 201348., 202790., 204232.,
      205674., 207116., 208558., 210000., 191191., 192647., 194103., 195559.,
      197015., 198471., 199927., 201383., 202839., 204295., 205751., 207207.,
      208663., 210119., 211575., 192570., 194040., 195510., 196980., 198450.,
      199920., 201390., 202860., 204330., 205800., 207270., 208740., 210210.,
      211680., 213150.};
  const int batches = 1;
  const int m = 14;
  const int k = 14;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK14xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      186200., 187488., 188776., 190064., 191352., 192640., 193928., 195216.,
      196504., 197792., 199080., 200368., 201656., 202944., 204232., 205520.,
      187670., 188972., 190274., 191576., 192878., 194180., 195482., 196784.,
      198086., 199388., 200690., 201992., 203294., 204596., 205898., 207200.,
      189140., 190456., 191772., 193088., 194404., 195720., 197036., 198352.,
      199668., 200984., 202300., 203616., 204932., 206248., 207564., 208880.,
      190610., 191940., 193270., 194600., 195930., 197260., 198590., 199920.,
      201250., 202580., 203910., 205240., 206570., 207900., 209230., 210560.,
      192080., 193424., 194768., 196112., 197456., 198800., 200144., 201488.,
      202832., 204176., 205520., 206864., 208208., 209552., 210896., 212240.,
      193550., 194908., 196266., 197624., 198982., 200340., 201698., 203056.,
      204414., 205772., 207130., 208488., 209846., 211204., 212562., 213920.,
      195020., 196392., 197764., 199136., 200508., 201880., 203252., 204624.,
      205996., 207368., 208740., 210112., 211484., 212856., 214228., 215600.,
      196490., 197876., 199262., 200648., 202034., 203420., 204806., 206192.,
      207578., 208964., 210350., 211736., 213122., 214508., 215894., 217280.,
      197960., 199360., 200760., 202160., 203560., 204960., 206360., 207760.,
      209160., 210560., 211960., 213360., 214760., 216160., 217560., 218960.,
      199430., 200844., 202258., 203672., 205086., 206500., 207914., 209328.,
      210742., 212156., 213570., 214984., 216398., 217812., 219226., 220640.,
      200900., 202328., 203756., 205184., 206612., 208040., 209468., 210896.,
      212324., 213752., 215180., 216608., 218036., 219464., 220892., 222320.,
      202370., 203812., 205254., 206696., 208138., 209580., 211022., 212464.,
      213906., 215348., 216790., 218232., 219674., 221116., 222558., 224000.,
      203840., 205296., 206752., 208208., 209664., 211120., 212576., 214032.,
      215488., 216944., 218400., 219856., 221312., 222768., 224224., 225680.,
      205310., 206780., 208250., 209720., 211190., 212660., 214130., 215600.,
      217070., 218540., 220010., 221480., 222950., 224420., 225890., 227360.};
  const int batches = 1;
  const int m = 14;
  const int k = 14;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK15xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      201895., 203380., 204865., 206350., 207835., 209320., 210805., 212290.,
      213775., 215260., 216745., 218230., 219715., 221200., 203380., 204880.,
      206380., 207880., 209380., 210880., 212380., 213880., 215380., 216880.,
      218380., 219880., 221380., 222880., 204865., 206380., 207895., 209410.,
      210925., 212440., 213955., 215470., 216985., 218500., 220015., 221530.,
      223045., 224560., 206350., 207880., 209410., 210940., 212470., 214000.,
      215530., 217060., 218590., 220120., 221650., 223180., 224710., 226240.,
      207835., 209380., 210925., 212470., 214015., 215560., 217105., 218650.,
      220195., 221740., 223285., 224830., 226375., 227920., 209320., 210880.,
      212440., 214000., 215560., 217120., 218680., 220240., 221800., 223360.,
      224920., 226480., 228040., 229600., 210805., 212380., 213955., 215530.,
      217105., 218680., 220255., 221830., 223405., 224980., 226555., 228130.,
      229705., 231280., 212290., 213880., 215470., 217060., 218650., 220240.,
      221830., 223420., 225010., 226600., 228190., 229780., 231370., 232960.,
      213775., 215380., 216985., 218590., 220195., 221800., 223405., 225010.,
      226615., 228220., 229825., 231430., 233035., 234640., 215260., 216880.,
      218500., 220120., 221740., 223360., 224980., 226600., 228220., 229840.,
      231460., 233080., 234700., 236320., 216745., 218380., 220015., 221650.,
      223285., 224920., 226555., 228190., 229825., 231460., 233095., 234730.,
      236365., 238000., 218230., 219880., 221530., 223180., 224830., 226480.,
      228130., 229780., 231430., 233080., 234730., 236380., 238030., 239680.,
      219715., 221380., 223045., 224710., 226375., 228040., 229705., 231370.,
      233035., 234700., 236365., 238030., 239695., 241360., 221200., 222880.,
      224560., 226240., 227920., 229600., 231280., 232960., 234640., 236320.,
      238000., 239680., 241360., 243040.};
  const int batches = 1;
  const int m = 14;
  const int k = 15;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK15xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      216210., 217695., 219180., 220665., 222150., 223635., 225120., 226605.,
      228090., 229575., 231060., 232545., 234030., 235515., 237000., 217800.,
      219300., 220800., 222300., 223800., 225300., 226800., 228300., 229800.,
      231300., 232800., 234300., 235800., 237300., 238800., 219390., 220905.,
      222420., 223935., 225450., 226965., 228480., 229995., 231510., 233025.,
      234540., 236055., 237570., 239085., 240600., 220980., 222510., 224040.,
      225570., 227100., 228630., 230160., 231690., 233220., 234750., 236280.,
      237810., 239340., 240870., 242400., 222570., 224115., 225660., 227205.,
      228750., 230295., 231840., 233385., 234930., 236475., 238020., 239565.,
      241110., 242655., 244200., 224160., 225720., 227280., 228840., 230400.,
      231960., 233520., 235080., 236640., 238200., 239760., 241320., 242880.,
      244440., 246000., 225750., 227325., 228900., 230475., 232050., 233625.,
      235200., 236775., 238350., 239925., 241500., 243075., 244650., 246225.,
      247800., 227340., 228930., 230520., 232110., 233700., 235290., 236880.,
      238470., 240060., 241650., 243240., 244830., 246420., 248010., 249600.,
      228930., 230535., 232140., 233745., 235350., 236955., 238560., 240165.,
      241770., 243375., 244980., 246585., 248190., 249795., 251400., 230520.,
      232140., 233760., 235380., 237000., 238620., 240240., 241860., 243480.,
      245100., 246720., 248340., 249960., 251580., 253200., 232110., 233745.,
      235380., 237015., 238650., 240285., 241920., 243555., 245190., 246825.,
      248460., 250095., 251730., 253365., 255000., 233700., 235350., 237000.,
      238650., 240300., 241950., 243600., 245250., 246900., 248550., 250200.,
      251850., 253500., 255150., 256800., 235290., 236955., 238620., 240285.,
      241950., 243615., 245280., 246945., 248610., 250275., 251940., 253605.,
      255270., 256935., 258600., 236880., 238560., 240240., 241920., 243600.,
      245280., 246960., 248640., 250320., 252000., 253680., 255360., 257040.,
      258720., 260400.};
  const int batches = 1;
  const int m = 14;
  const int k = 15;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK15xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      230525., 232010., 233495., 234980., 236465., 237950., 239435., 240920.,
      242405., 243890., 245375., 246860., 248345., 249830., 251315., 252800.,
      232220., 233720., 235220., 236720., 238220., 239720., 241220., 242720.,
      244220., 245720., 247220., 248720., 250220., 251720., 253220., 254720.,
      233915., 235430., 236945., 238460., 239975., 241490., 243005., 244520.,
      246035., 247550., 249065., 250580., 252095., 253610., 255125., 256640.,
      235610., 237140., 238670., 240200., 241730., 243260., 244790., 246320.,
      247850., 249380., 250910., 252440., 253970., 255500., 257030., 258560.,
      237305., 238850., 240395., 241940., 243485., 245030., 246575., 248120.,
      249665., 251210., 252755., 254300., 255845., 257390., 258935., 260480.,
      239000., 240560., 242120., 243680., 245240., 246800., 248360., 249920.,
      251480., 253040., 254600., 256160., 257720., 259280., 260840., 262400.,
      240695., 242270., 243845., 245420., 246995., 248570., 250145., 251720.,
      253295., 254870., 256445., 258020., 259595., 261170., 262745., 264320.,
      242390., 243980., 245570., 247160., 248750., 250340., 251930., 253520.,
      255110., 256700., 258290., 259880., 261470., 263060., 264650., 266240.,
      244085., 245690., 247295., 248900., 250505., 252110., 253715., 255320.,
      256925., 258530., 260135., 261740., 263345., 264950., 266555., 268160.,
      245780., 247400., 249020., 250640., 252260., 253880., 255500., 257120.,
      258740., 260360., 261980., 263600., 265220., 266840., 268460., 270080.,
      247475., 249110., 250745., 252380., 254015., 255650., 257285., 258920.,
      260555., 262190., 263825., 265460., 267095., 268730., 270365., 272000.,
      249170., 250820., 252470., 254120., 255770., 257420., 259070., 260720.,
      262370., 264020., 265670., 267320., 268970., 270620., 272270., 273920.,
      250865., 252530., 254195., 255860., 257525., 259190., 260855., 262520.,
      264185., 265850., 267515., 269180., 270845., 272510., 274175., 275840.,
      252560., 254240., 255920., 257600., 259280., 260960., 262640., 264320.,
      266000., 267680., 269360., 271040., 272720., 274400., 276080., 277760.};
  const int batches = 1;
  const int m = 14;
  const int k = 15;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK16xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      246416., 248112., 249808., 251504., 253200., 254896., 256592., 258288.,
      259984., 261680., 263376., 265072., 266768., 268464., 248112., 249824.,
      251536., 253248., 254960., 256672., 258384., 260096., 261808., 263520.,
      265232., 266944., 268656., 270368., 249808., 251536., 253264., 254992.,
      256720., 258448., 260176., 261904., 263632., 265360., 267088., 268816.,
      270544., 272272., 251504., 253248., 254992., 256736., 258480., 260224.,
      261968., 263712., 265456., 267200., 268944., 270688., 272432., 274176.,
      253200., 254960., 256720., 258480., 260240., 262000., 263760., 265520.,
      267280., 269040., 270800., 272560., 274320., 276080., 254896., 256672.,
      258448., 260224., 262000., 263776., 265552., 267328., 269104., 270880.,
      272656., 274432., 276208., 277984., 256592., 258384., 260176., 261968.,
      263760., 265552., 267344., 269136., 270928., 272720., 274512., 276304.,
      278096., 279888., 258288., 260096., 261904., 263712., 265520., 267328.,
      269136., 270944., 272752., 274560., 276368., 278176., 279984., 281792.,
      259984., 261808., 263632., 265456., 267280., 269104., 270928., 272752.,
      274576., 276400., 278224., 280048., 281872., 283696., 261680., 263520.,
      265360., 267200., 269040., 270880., 272720., 274560., 276400., 278240.,
      280080., 281920., 283760., 285600., 263376., 265232., 267088., 268944.,
      270800., 272656., 274512., 276368., 278224., 280080., 281936., 283792.,
      285648., 287504., 265072., 266944., 268816., 270688., 272560., 274432.,
      276304., 278176., 280048., 281920., 283792., 285664., 287536., 289408.,
      266768., 268656., 270544., 272432., 274320., 276208., 278096., 279984.,
      281872., 283760., 285648., 287536., 289424., 291312., 268464., 270368.,
      272272., 274176., 276080., 277984., 279888., 281792., 283696., 285600.,
      287504., 289408., 291312., 293216.};
  const int batches = 1;
  const int m = 14;
  const int k = 16;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK16xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      263896., 265592., 267288., 268984., 270680., 272376., 274072., 275768.,
      277464., 279160., 280856., 282552., 284248., 285944., 287640., 265712.,
      267424., 269136., 270848., 272560., 274272., 275984., 277696., 279408.,
      281120., 282832., 284544., 286256., 287968., 289680., 267528., 269256.,
      270984., 272712., 274440., 276168., 277896., 279624., 281352., 283080.,
      284808., 286536., 288264., 289992., 291720., 269344., 271088., 272832.,
      274576., 276320., 278064., 279808., 281552., 283296., 285040., 286784.,
      288528., 290272., 292016., 293760., 271160., 272920., 274680., 276440.,
      278200., 279960., 281720., 283480., 285240., 287000., 288760., 290520.,
      292280., 294040., 295800., 272976., 274752., 276528., 278304., 280080.,
      281856., 283632., 285408., 287184., 288960., 290736., 292512., 294288.,
      296064., 297840., 274792., 276584., 278376., 280168., 281960., 283752.,
      285544., 287336., 289128., 290920., 292712., 294504., 296296., 298088.,
      299880., 276608., 278416., 280224., 282032., 283840., 285648., 287456.,
      289264., 291072., 292880., 294688., 296496., 298304., 300112., 301920.,
      278424., 280248., 282072., 283896., 285720., 287544., 289368., 291192.,
      293016., 294840., 296664., 298488., 300312., 302136., 303960., 280240.,
      282080., 283920., 285760., 287600., 289440., 291280., 293120., 294960.,
      296800., 298640., 300480., 302320., 304160., 306000., 282056., 283912.,
      285768., 287624., 289480., 291336., 293192., 295048., 296904., 298760.,
      300616., 302472., 304328., 306184., 308040., 283872., 285744., 287616.,
      289488., 291360., 293232., 295104., 296976., 298848., 300720., 302592.,
      304464., 306336., 308208., 310080., 285688., 287576., 289464., 291352.,
      293240., 295128., 297016., 298904., 300792., 302680., 304568., 306456.,
      308344., 310232., 312120., 287504., 289408., 291312., 293216., 295120.,
      297024., 298928., 300832., 302736., 304640., 306544., 308448., 310352.,
      312256., 314160.};
  const int batches = 1;
  const int m = 14;
  const int k = 16;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M14xK16xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      281376., 283072., 284768., 286464., 288160., 289856., 291552., 293248.,
      294944., 296640., 298336., 300032., 301728., 303424., 305120., 306816.,
      283312., 285024., 286736., 288448., 290160., 291872., 293584., 295296.,
      297008., 298720., 300432., 302144., 303856., 305568., 307280., 308992.,
      285248., 286976., 288704., 290432., 292160., 293888., 295616., 297344.,
      299072., 300800., 302528., 304256., 305984., 307712., 309440., 311168.,
      287184., 288928., 290672., 292416., 294160., 295904., 297648., 299392.,
      301136., 302880., 304624., 306368., 308112., 309856., 311600., 313344.,
      289120., 290880., 292640., 294400., 296160., 297920., 299680., 301440.,
      303200., 304960., 306720., 308480., 310240., 312000., 313760., 315520.,
      291056., 292832., 294608., 296384., 298160., 299936., 301712., 303488.,
      305264., 307040., 308816., 310592., 312368., 314144., 315920., 317696.,
      292992., 294784., 296576., 298368., 300160., 301952., 303744., 305536.,
      307328., 309120., 310912., 312704., 314496., 316288., 318080., 319872.,
      294928., 296736., 298544., 300352., 302160., 303968., 305776., 307584.,
      309392., 311200., 313008., 314816., 316624., 318432., 320240., 322048.,
      296864., 298688., 300512., 302336., 304160., 305984., 307808., 309632.,
      311456., 313280., 315104., 316928., 318752., 320576., 322400., 324224.,
      298800., 300640., 302480., 304320., 306160., 308000., 309840., 311680.,
      313520., 315360., 317200., 319040., 320880., 322720., 324560., 326400.,
      300736., 302592., 304448., 306304., 308160., 310016., 311872., 313728.,
      315584., 317440., 319296., 321152., 323008., 324864., 326720., 328576.,
      302672., 304544., 306416., 308288., 310160., 312032., 313904., 315776.,
      317648., 319520., 321392., 323264., 325136., 327008., 328880., 330752.,
      304608., 306496., 308384., 310272., 312160., 314048., 315936., 317824.,
      319712., 321600., 323488., 325376., 327264., 329152., 331040., 332928.,
      306544., 308448., 310352., 312256., 314160., 316064., 317968., 319872.,
      321776., 323680., 325584., 327488., 329392., 331296., 333200., 335104.};
  const int batches = 1;
  const int m = 14;
  const int k = 16;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK14xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      174643., 176022., 177401., 178780., 180159., 181538., 182917., 184296.,
      185675., 187054., 188433., 189812., 191191., 192570., 175931., 177324.,
      178717., 180110., 181503., 182896., 184289., 185682., 187075., 188468.,
      189861., 191254., 192647., 194040., 177219., 178626., 180033., 181440.,
      182847., 184254., 185661., 187068., 188475., 189882., 191289., 192696.,
      194103., 195510., 178507., 179928., 181349., 182770., 184191., 185612.,
      187033., 188454., 189875., 191296., 192717., 194138., 195559., 196980.,
      179795., 181230., 182665., 184100., 185535., 186970., 188405., 189840.,
      191275., 192710., 194145., 195580., 197015., 198450., 181083., 182532.,
      183981., 185430., 186879., 188328., 189777., 191226., 192675., 194124.,
      195573., 197022., 198471., 199920., 182371., 183834., 185297., 186760.,
      188223., 189686., 191149., 192612., 194075., 195538., 197001., 198464.,
      199927., 201390., 183659., 185136., 186613., 188090., 189567., 191044.,
      192521., 193998., 195475., 196952., 198429., 199906., 201383., 202860.,
      184947., 186438., 187929., 189420., 190911., 192402., 193893., 195384.,
      196875., 198366., 199857., 201348., 202839., 204330., 186235., 187740.,
      189245., 190750., 192255., 193760., 195265., 196770., 198275., 199780.,
      201285., 202790., 204295., 205800., 187523., 189042., 190561., 192080.,
      193599., 195118., 196637., 198156., 199675., 201194., 202713., 204232.,
      205751., 207270., 188811., 190344., 191877., 193410., 194943., 196476.,
      198009., 199542., 201075., 202608., 204141., 205674., 207207., 208740.,
      190099., 191646., 193193., 194740., 196287., 197834., 199381., 200928.,
      202475., 204022., 205569., 207116., 208663., 210210., 191387., 192948.,
      194509., 196070., 197631., 199192., 200753., 202314., 203875., 205436.,
      206997., 208558., 210119., 211680., 192675., 194250., 195825., 197400.,
      198975., 200550., 202125., 203700., 205275., 206850., 208425., 210000.,
      211575., 213150.};
  const int batches = 1;
  const int m = 15;
  const int k = 14;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK14xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      187019., 188398., 189777., 191156., 192535., 193914., 195293., 196672.,
      198051., 199430., 200809., 202188., 203567., 204946., 206325., 188398.,
      189791., 191184., 192577., 193970., 195363., 196756., 198149., 199542.,
      200935., 202328., 203721., 205114., 206507., 207900., 189777., 191184.,
      192591., 193998., 195405., 196812., 198219., 199626., 201033., 202440.,
      203847., 205254., 206661., 208068., 209475., 191156., 192577., 193998.,
      195419., 196840., 198261., 199682., 201103., 202524., 203945., 205366.,
      206787., 208208., 209629., 211050., 192535., 193970., 195405., 196840.,
      198275., 199710., 201145., 202580., 204015., 205450., 206885., 208320.,
      209755., 211190., 212625., 193914., 195363., 196812., 198261., 199710.,
      201159., 202608., 204057., 205506., 206955., 208404., 209853., 211302.,
      212751., 214200., 195293., 196756., 198219., 199682., 201145., 202608.,
      204071., 205534., 206997., 208460., 209923., 211386., 212849., 214312.,
      215775., 196672., 198149., 199626., 201103., 202580., 204057., 205534.,
      207011., 208488., 209965., 211442., 212919., 214396., 215873., 217350.,
      198051., 199542., 201033., 202524., 204015., 205506., 206997., 208488.,
      209979., 211470., 212961., 214452., 215943., 217434., 218925., 199430.,
      200935., 202440., 203945., 205450., 206955., 208460., 209965., 211470.,
      212975., 214480., 215985., 217490., 218995., 220500., 200809., 202328.,
      203847., 205366., 206885., 208404., 209923., 211442., 212961., 214480.,
      215999., 217518., 219037., 220556., 222075., 202188., 203721., 205254.,
      206787., 208320., 209853., 211386., 212919., 214452., 215985., 217518.,
      219051., 220584., 222117., 223650., 203567., 205114., 206661., 208208.,
      209755., 211302., 212849., 214396., 215943., 217490., 219037., 220584.,
      222131., 223678., 225225., 204946., 206507., 208068., 209629., 211190.,
      212751., 214312., 215873., 217434., 218995., 220556., 222117., 223678.,
      225239., 226800., 206325., 207900., 209475., 211050., 212625., 214200.,
      215775., 217350., 218925., 220500., 222075., 223650., 225225., 226800.,
      228375.};
  const int batches = 1;
  const int m = 15;
  const int k = 14;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK14xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      199395., 200774., 202153., 203532., 204911., 206290., 207669., 209048.,
      210427., 211806., 213185., 214564., 215943., 217322., 218701., 220080.,
      200865., 202258., 203651., 205044., 206437., 207830., 209223., 210616.,
      212009., 213402., 214795., 216188., 217581., 218974., 220367., 221760.,
      202335., 203742., 205149., 206556., 207963., 209370., 210777., 212184.,
      213591., 214998., 216405., 217812., 219219., 220626., 222033., 223440.,
      203805., 205226., 206647., 208068., 209489., 210910., 212331., 213752.,
      215173., 216594., 218015., 219436., 220857., 222278., 223699., 225120.,
      205275., 206710., 208145., 209580., 211015., 212450., 213885., 215320.,
      216755., 218190., 219625., 221060., 222495., 223930., 225365., 226800.,
      206745., 208194., 209643., 211092., 212541., 213990., 215439., 216888.,
      218337., 219786., 221235., 222684., 224133., 225582., 227031., 228480.,
      208215., 209678., 211141., 212604., 214067., 215530., 216993., 218456.,
      219919., 221382., 222845., 224308., 225771., 227234., 228697., 230160.,
      209685., 211162., 212639., 214116., 215593., 217070., 218547., 220024.,
      221501., 222978., 224455., 225932., 227409., 228886., 230363., 231840.,
      211155., 212646., 214137., 215628., 217119., 218610., 220101., 221592.,
      223083., 224574., 226065., 227556., 229047., 230538., 232029., 233520.,
      212625., 214130., 215635., 217140., 218645., 220150., 221655., 223160.,
      224665., 226170., 227675., 229180., 230685., 232190., 233695., 235200.,
      214095., 215614., 217133., 218652., 220171., 221690., 223209., 224728.,
      226247., 227766., 229285., 230804., 232323., 233842., 235361., 236880.,
      215565., 217098., 218631., 220164., 221697., 223230., 224763., 226296.,
      227829., 229362., 230895., 232428., 233961., 235494., 237027., 238560.,
      217035., 218582., 220129., 221676., 223223., 224770., 226317., 227864.,
      229411., 230958., 232505., 234052., 235599., 237146., 238693., 240240.,
      218505., 220066., 221627., 223188., 224749., 226310., 227871., 229432.,
      230993., 232554., 234115., 235676., 237237., 238798., 240359., 241920.,
      219975., 221550., 223125., 224700., 226275., 227850., 229425., 231000.,
      232575., 234150., 235725., 237300., 238875., 240450., 242025., 243600.};
  const int batches = 1;
  const int m = 15;
  const int k = 14;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK15xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      216210., 217800., 219390., 220980., 222570., 224160., 225750., 227340.,
      228930., 230520., 232110., 233700., 235290., 236880., 217695., 219300.,
      220905., 222510., 224115., 225720., 227325., 228930., 230535., 232140.,
      233745., 235350., 236955., 238560., 219180., 220800., 222420., 224040.,
      225660., 227280., 228900., 230520., 232140., 233760., 235380., 237000.,
      238620., 240240., 220665., 222300., 223935., 225570., 227205., 228840.,
      230475., 232110., 233745., 235380., 237015., 238650., 240285., 241920.,
      222150., 223800., 225450., 227100., 228750., 230400., 232050., 233700.,
      235350., 237000., 238650., 240300., 241950., 243600., 223635., 225300.,
      226965., 228630., 230295., 231960., 233625., 235290., 236955., 238620.,
      240285., 241950., 243615., 245280., 225120., 226800., 228480., 230160.,
      231840., 233520., 235200., 236880., 238560., 240240., 241920., 243600.,
      245280., 246960., 226605., 228300., 229995., 231690., 233385., 235080.,
      236775., 238470., 240165., 241860., 243555., 245250., 246945., 248640.,
      228090., 229800., 231510., 233220., 234930., 236640., 238350., 240060.,
      241770., 243480., 245190., 246900., 248610., 250320., 229575., 231300.,
      233025., 234750., 236475., 238200., 239925., 241650., 243375., 245100.,
      246825., 248550., 250275., 252000., 231060., 232800., 234540., 236280.,
      238020., 239760., 241500., 243240., 244980., 246720., 248460., 250200.,
      251940., 253680., 232545., 234300., 236055., 237810., 239565., 241320.,
      243075., 244830., 246585., 248340., 250095., 251850., 253605., 255360.,
      234030., 235800., 237570., 239340., 241110., 242880., 244650., 246420.,
      248190., 249960., 251730., 253500., 255270., 257040., 235515., 237300.,
      239085., 240870., 242655., 244440., 246225., 248010., 249795., 251580.,
      253365., 255150., 256935., 258720., 237000., 238800., 240600., 242400.,
      244200., 246000., 247800., 249600., 251400., 253200., 255000., 256800.,
      258600., 260400.};
  const int batches = 1;
  const int m = 15;
  const int k = 15;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK15xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      231540., 233130., 234720., 236310., 237900., 239490., 241080., 242670.,
      244260., 245850., 247440., 249030., 250620., 252210., 253800., 233130.,
      234735., 236340., 237945., 239550., 241155., 242760., 244365., 245970.,
      247575., 249180., 250785., 252390., 253995., 255600., 234720., 236340.,
      237960., 239580., 241200., 242820., 244440., 246060., 247680., 249300.,
      250920., 252540., 254160., 255780., 257400., 236310., 237945., 239580.,
      241215., 242850., 244485., 246120., 247755., 249390., 251025., 252660.,
      254295., 255930., 257565., 259200., 237900., 239550., 241200., 242850.,
      244500., 246150., 247800., 249450., 251100., 252750., 254400., 256050.,
      257700., 259350., 261000., 239490., 241155., 242820., 244485., 246150.,
      247815., 249480., 251145., 252810., 254475., 256140., 257805., 259470.,
      261135., 262800., 241080., 242760., 244440., 246120., 247800., 249480.,
      251160., 252840., 254520., 256200., 257880., 259560., 261240., 262920.,
      264600., 242670., 244365., 246060., 247755., 249450., 251145., 252840.,
      254535., 256230., 257925., 259620., 261315., 263010., 264705., 266400.,
      244260., 245970., 247680., 249390., 251100., 252810., 254520., 256230.,
      257940., 259650., 261360., 263070., 264780., 266490., 268200., 245850.,
      247575., 249300., 251025., 252750., 254475., 256200., 257925., 259650.,
      261375., 263100., 264825., 266550., 268275., 270000., 247440., 249180.,
      250920., 252660., 254400., 256140., 257880., 259620., 261360., 263100.,
      264840., 266580., 268320., 270060., 271800., 249030., 250785., 252540.,
      254295., 256050., 257805., 259560., 261315., 263070., 264825., 266580.,
      268335., 270090., 271845., 273600., 250620., 252390., 254160., 255930.,
      257700., 259470., 261240., 263010., 264780., 266550., 268320., 270090.,
      271860., 273630., 275400., 252210., 253995., 255780., 257565., 259350.,
      261135., 262920., 264705., 266490., 268275., 270060., 271845., 273630.,
      275415., 277200., 253800., 255600., 257400., 259200., 261000., 262800.,
      264600., 266400., 268200., 270000., 271800., 273600., 275400., 277200.,
      279000.};
  const int batches = 1;
  const int m = 15;
  const int k = 15;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK15xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      246870., 248460., 250050., 251640., 253230., 254820., 256410., 258000.,
      259590., 261180., 262770., 264360., 265950., 267540., 269130., 270720.,
      248565., 250170., 251775., 253380., 254985., 256590., 258195., 259800.,
      261405., 263010., 264615., 266220., 267825., 269430., 271035., 272640.,
      250260., 251880., 253500., 255120., 256740., 258360., 259980., 261600.,
      263220., 264840., 266460., 268080., 269700., 271320., 272940., 274560.,
      251955., 253590., 255225., 256860., 258495., 260130., 261765., 263400.,
      265035., 266670., 268305., 269940., 271575., 273210., 274845., 276480.,
      253650., 255300., 256950., 258600., 260250., 261900., 263550., 265200.,
      266850., 268500., 270150., 271800., 273450., 275100., 276750., 278400.,
      255345., 257010., 258675., 260340., 262005., 263670., 265335., 267000.,
      268665., 270330., 271995., 273660., 275325., 276990., 278655., 280320.,
      257040., 258720., 260400., 262080., 263760., 265440., 267120., 268800.,
      270480., 272160., 273840., 275520., 277200., 278880., 280560., 282240.,
      258735., 260430., 262125., 263820., 265515., 267210., 268905., 270600.,
      272295., 273990., 275685., 277380., 279075., 280770., 282465., 284160.,
      260430., 262140., 263850., 265560., 267270., 268980., 270690., 272400.,
      274110., 275820., 277530., 279240., 280950., 282660., 284370., 286080.,
      262125., 263850., 265575., 267300., 269025., 270750., 272475., 274200.,
      275925., 277650., 279375., 281100., 282825., 284550., 286275., 288000.,
      263820., 265560., 267300., 269040., 270780., 272520., 274260., 276000.,
      277740., 279480., 281220., 282960., 284700., 286440., 288180., 289920.,
      265515., 267270., 269025., 270780., 272535., 274290., 276045., 277800.,
      279555., 281310., 283065., 284820., 286575., 288330., 290085., 291840.,
      267210., 268980., 270750., 272520., 274290., 276060., 277830., 279600.,
      281370., 283140., 284910., 286680., 288450., 290220., 291990., 293760.,
      268905., 270690., 272475., 274260., 276045., 277830., 279615., 281400.,
      283185., 284970., 286755., 288540., 290325., 292110., 293895., 295680.,
      270600., 272400., 274200., 276000., 277800., 279600., 281400., 283200.,
      285000., 286800., 288600., 290400., 292200., 294000., 295800., 297600.};
  const int batches = 1;
  const int m = 15;
  const int k = 15;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK16xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      263896., 265712., 267528., 269344., 271160., 272976., 274792., 276608.,
      278424., 280240., 282056., 283872., 285688., 287504., 265592., 267424.,
      269256., 271088., 272920., 274752., 276584., 278416., 280248., 282080.,
      283912., 285744., 287576., 289408., 267288., 269136., 270984., 272832.,
      274680., 276528., 278376., 280224., 282072., 283920., 285768., 287616.,
      289464., 291312., 268984., 270848., 272712., 274576., 276440., 278304.,
      280168., 282032., 283896., 285760., 287624., 289488., 291352., 293216.,
      270680., 272560., 274440., 276320., 278200., 280080., 281960., 283840.,
      285720., 287600., 289480., 291360., 293240., 295120., 272376., 274272.,
      276168., 278064., 279960., 281856., 283752., 285648., 287544., 289440.,
      291336., 293232., 295128., 297024., 274072., 275984., 277896., 279808.,
      281720., 283632., 285544., 287456., 289368., 291280., 293192., 295104.,
      297016., 298928., 275768., 277696., 279624., 281552., 283480., 285408.,
      287336., 289264., 291192., 293120., 295048., 296976., 298904., 300832.,
      277464., 279408., 281352., 283296., 285240., 287184., 289128., 291072.,
      293016., 294960., 296904., 298848., 300792., 302736., 279160., 281120.,
      283080., 285040., 287000., 288960., 290920., 292880., 294840., 296800.,
      298760., 300720., 302680., 304640., 280856., 282832., 284808., 286784.,
      288760., 290736., 292712., 294688., 296664., 298640., 300616., 302592.,
      304568., 306544., 282552., 284544., 286536., 288528., 290520., 292512.,
      294504., 296496., 298488., 300480., 302472., 304464., 306456., 308448.,
      284248., 286256., 288264., 290272., 292280., 294288., 296296., 298304.,
      300312., 302320., 304328., 306336., 308344., 310352., 285944., 287968.,
      289992., 292016., 294040., 296064., 298088., 300112., 302136., 304160.,
      306184., 308208., 310232., 312256., 287640., 289680., 291720., 293760.,
      295800., 297840., 299880., 301920., 303960., 306000., 308040., 310080.,
      312120., 314160.};
  const int batches = 1;
  const int m = 15;
  const int k = 16;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK16xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      282616., 284432., 286248., 288064., 289880., 291696., 293512., 295328.,
      297144., 298960., 300776., 302592., 304408., 306224., 308040., 284432.,
      286264., 288096., 289928., 291760., 293592., 295424., 297256., 299088.,
      300920., 302752., 304584., 306416., 308248., 310080., 286248., 288096.,
      289944., 291792., 293640., 295488., 297336., 299184., 301032., 302880.,
      304728., 306576., 308424., 310272., 312120., 288064., 289928., 291792.,
      293656., 295520., 297384., 299248., 301112., 302976., 304840., 306704.,
      308568., 310432., 312296., 314160., 289880., 291760., 293640., 295520.,
      297400., 299280., 301160., 303040., 304920., 306800., 308680., 310560.,
      312440., 314320., 316200., 291696., 293592., 295488., 297384., 299280.,
      301176., 303072., 304968., 306864., 308760., 310656., 312552., 314448.,
      316344., 318240., 293512., 295424., 297336., 299248., 301160., 303072.,
      304984., 306896., 308808., 310720., 312632., 314544., 316456., 318368.,
      320280., 295328., 297256., 299184., 301112., 303040., 304968., 306896.,
      308824., 310752., 312680., 314608., 316536., 318464., 320392., 322320.,
      297144., 299088., 301032., 302976., 304920., 306864., 308808., 310752.,
      312696., 314640., 316584., 318528., 320472., 322416., 324360., 298960.,
      300920., 302880., 304840., 306800., 308760., 310720., 312680., 314640.,
      316600., 318560., 320520., 322480., 324440., 326400., 300776., 302752.,
      304728., 306704., 308680., 310656., 312632., 314608., 316584., 318560.,
      320536., 322512., 324488., 326464., 328440., 302592., 304584., 306576.,
      308568., 310560., 312552., 314544., 316536., 318528., 320520., 322512.,
      324504., 326496., 328488., 330480., 304408., 306416., 308424., 310432.,
      312440., 314448., 316456., 318464., 320472., 322480., 324488., 326496.,
      328504., 330512., 332520., 306224., 308248., 310272., 312296., 314320.,
      316344., 318368., 320392., 322416., 324440., 326464., 328488., 330512.,
      332536., 334560., 308040., 310080., 312120., 314160., 316200., 318240.,
      320280., 322320., 324360., 326400., 328440., 330480., 332520., 334560.,
      336600.};
  const int batches = 1;
  const int m = 15;
  const int k = 16;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M15xK16xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      301336., 303152., 304968., 306784., 308600., 310416., 312232., 314048.,
      315864., 317680., 319496., 321312., 323128., 324944., 326760., 328576.,
      303272., 305104., 306936., 308768., 310600., 312432., 314264., 316096.,
      317928., 319760., 321592., 323424., 325256., 327088., 328920., 330752.,
      305208., 307056., 308904., 310752., 312600., 314448., 316296., 318144.,
      319992., 321840., 323688., 325536., 327384., 329232., 331080., 332928.,
      307144., 309008., 310872., 312736., 314600., 316464., 318328., 320192.,
      322056., 323920., 325784., 327648., 329512., 331376., 333240., 335104.,
      309080., 310960., 312840., 314720., 316600., 318480., 320360., 322240.,
      324120., 326000., 327880., 329760., 331640., 333520., 335400., 337280.,
      311016., 312912., 314808., 316704., 318600., 320496., 322392., 324288.,
      326184., 328080., 329976., 331872., 333768., 335664., 337560., 339456.,
      312952., 314864., 316776., 318688., 320600., 322512., 324424., 326336.,
      328248., 330160., 332072., 333984., 335896., 337808., 339720., 341632.,
      314888., 316816., 318744., 320672., 322600., 324528., 326456., 328384.,
      330312., 332240., 334168., 336096., 338024., 339952., 341880., 343808.,
      316824., 318768., 320712., 322656., 324600., 326544., 328488., 330432.,
      332376., 334320., 336264., 338208., 340152., 342096., 344040., 345984.,
      318760., 320720., 322680., 324640., 326600., 328560., 330520., 332480.,
      334440., 336400., 338360., 340320., 342280., 344240., 346200., 348160.,
      320696., 322672., 324648., 326624., 328600., 330576., 332552., 334528.,
      336504., 338480., 340456., 342432., 344408., 346384., 348360., 350336.,
      322632., 324624., 326616., 328608., 330600., 332592., 334584., 336576.,
      338568., 340560., 342552., 344544., 346536., 348528., 350520., 352512.,
      324568., 326576., 328584., 330592., 332600., 334608., 336616., 338624.,
      340632., 342640., 344648., 346656., 348664., 350672., 352680., 354688.,
      326504., 328528., 330552., 332576., 334600., 336624., 338648., 340672.,
      342696., 344720., 346744., 348768., 350792., 352816., 354840., 356864.,
      328440., 330480., 332520., 334560., 336600., 338640., 340680., 342720.,
      344760., 346800., 348840., 350880., 352920., 354960., 357000., 359040.};
  const int batches = 1;
  const int m = 15;
  const int k = 16;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK14xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      186200., 187670., 189140., 190610., 192080., 193550., 195020., 196490.,
      197960., 199430., 200900., 202370., 203840., 205310., 187488., 188972.,
      190456., 191940., 193424., 194908., 196392., 197876., 199360., 200844.,
      202328., 203812., 205296., 206780., 188776., 190274., 191772., 193270.,
      194768., 196266., 197764., 199262., 200760., 202258., 203756., 205254.,
      206752., 208250., 190064., 191576., 193088., 194600., 196112., 197624.,
      199136., 200648., 202160., 203672., 205184., 206696., 208208., 209720.,
      191352., 192878., 194404., 195930., 197456., 198982., 200508., 202034.,
      203560., 205086., 206612., 208138., 209664., 211190., 192640., 194180.,
      195720., 197260., 198800., 200340., 201880., 203420., 204960., 206500.,
      208040., 209580., 211120., 212660., 193928., 195482., 197036., 198590.,
      200144., 201698., 203252., 204806., 206360., 207914., 209468., 211022.,
      212576., 214130., 195216., 196784., 198352., 199920., 201488., 203056.,
      204624., 206192., 207760., 209328., 210896., 212464., 214032., 215600.,
      196504., 198086., 199668., 201250., 202832., 204414., 205996., 207578.,
      209160., 210742., 212324., 213906., 215488., 217070., 197792., 199388.,
      200984., 202580., 204176., 205772., 207368., 208964., 210560., 212156.,
      213752., 215348., 216944., 218540., 199080., 200690., 202300., 203910.,
      205520., 207130., 208740., 210350., 211960., 213570., 215180., 216790.,
      218400., 220010., 200368., 201992., 203616., 205240., 206864., 208488.,
      210112., 211736., 213360., 214984., 216608., 218232., 219856., 221480.,
      201656., 203294., 204932., 206570., 208208., 209846., 211484., 213122.,
      214760., 216398., 218036., 219674., 221312., 222950., 202944., 204596.,
      206248., 207900., 209552., 211204., 212856., 214508., 216160., 217812.,
      219464., 221116., 222768., 224420., 204232., 205898., 207564., 209230.,
      210896., 212562., 214228., 215894., 217560., 219226., 220892., 222558.,
      224224., 225890., 205520., 207200., 208880., 210560., 212240., 213920.,
      215600., 217280., 218960., 220640., 222320., 224000., 225680., 227360.};
  const int batches = 1;
  const int m = 16;
  const int k = 14;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK14xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      199395., 200865., 202335., 203805., 205275., 206745., 208215., 209685.,
      211155., 212625., 214095., 215565., 217035., 218505., 219975., 200774.,
      202258., 203742., 205226., 206710., 208194., 209678., 211162., 212646.,
      214130., 215614., 217098., 218582., 220066., 221550., 202153., 203651.,
      205149., 206647., 208145., 209643., 211141., 212639., 214137., 215635.,
      217133., 218631., 220129., 221627., 223125., 203532., 205044., 206556.,
      208068., 209580., 211092., 212604., 214116., 215628., 217140., 218652.,
      220164., 221676., 223188., 224700., 204911., 206437., 207963., 209489.,
      211015., 212541., 214067., 215593., 217119., 218645., 220171., 221697.,
      223223., 224749., 226275., 206290., 207830., 209370., 210910., 212450.,
      213990., 215530., 217070., 218610., 220150., 221690., 223230., 224770.,
      226310., 227850., 207669., 209223., 210777., 212331., 213885., 215439.,
      216993., 218547., 220101., 221655., 223209., 224763., 226317., 227871.,
      229425., 209048., 210616., 212184., 213752., 215320., 216888., 218456.,
      220024., 221592., 223160., 224728., 226296., 227864., 229432., 231000.,
      210427., 212009., 213591., 215173., 216755., 218337., 219919., 221501.,
      223083., 224665., 226247., 227829., 229411., 230993., 232575., 211806.,
      213402., 214998., 216594., 218190., 219786., 221382., 222978., 224574.,
      226170., 227766., 229362., 230958., 232554., 234150., 213185., 214795.,
      216405., 218015., 219625., 221235., 222845., 224455., 226065., 227675.,
      229285., 230895., 232505., 234115., 235725., 214564., 216188., 217812.,
      219436., 221060., 222684., 224308., 225932., 227556., 229180., 230804.,
      232428., 234052., 235676., 237300., 215943., 217581., 219219., 220857.,
      222495., 224133., 225771., 227409., 229047., 230685., 232323., 233961.,
      235599., 237237., 238875., 217322., 218974., 220626., 222278., 223930.,
      225582., 227234., 228886., 230538., 232190., 233842., 235494., 237146.,
      238798., 240450., 218701., 220367., 222033., 223699., 225365., 227031.,
      228697., 230363., 232029., 233695., 235361., 237027., 238693., 240359.,
      242025., 220080., 221760., 223440., 225120., 226800., 228480., 230160.,
      231840., 233520., 235200., 236880., 238560., 240240., 241920., 243600.};
  const int batches = 1;
  const int m = 16;
  const int k = 14;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK14xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      212590., 214060., 215530., 217000., 218470., 219940., 221410., 222880.,
      224350., 225820., 227290., 228760., 230230., 231700., 233170., 234640.,
      214060., 215544., 217028., 218512., 219996., 221480., 222964., 224448.,
      225932., 227416., 228900., 230384., 231868., 233352., 234836., 236320.,
      215530., 217028., 218526., 220024., 221522., 223020., 224518., 226016.,
      227514., 229012., 230510., 232008., 233506., 235004., 236502., 238000.,
      217000., 218512., 220024., 221536., 223048., 224560., 226072., 227584.,
      229096., 230608., 232120., 233632., 235144., 236656., 238168., 239680.,
      218470., 219996., 221522., 223048., 224574., 226100., 227626., 229152.,
      230678., 232204., 233730., 235256., 236782., 238308., 239834., 241360.,
      219940., 221480., 223020., 224560., 226100., 227640., 229180., 230720.,
      232260., 233800., 235340., 236880., 238420., 239960., 241500., 243040.,
      221410., 222964., 224518., 226072., 227626., 229180., 230734., 232288.,
      233842., 235396., 236950., 238504., 240058., 241612., 243166., 244720.,
      222880., 224448., 226016., 227584., 229152., 230720., 232288., 233856.,
      235424., 236992., 238560., 240128., 241696., 243264., 244832., 246400.,
      224350., 225932., 227514., 229096., 230678., 232260., 233842., 235424.,
      237006., 238588., 240170., 241752., 243334., 244916., 246498., 248080.,
      225820., 227416., 229012., 230608., 232204., 233800., 235396., 236992.,
      238588., 240184., 241780., 243376., 244972., 246568., 248164., 249760.,
      227290., 228900., 230510., 232120., 233730., 235340., 236950., 238560.,
      240170., 241780., 243390., 245000., 246610., 248220., 249830., 251440.,
      228760., 230384., 232008., 233632., 235256., 236880., 238504., 240128.,
      241752., 243376., 245000., 246624., 248248., 249872., 251496., 253120.,
      230230., 231868., 233506., 235144., 236782., 238420., 240058., 241696.,
      243334., 244972., 246610., 248248., 249886., 251524., 253162., 254800.,
      231700., 233352., 235004., 236656., 238308., 239960., 241612., 243264.,
      244916., 246568., 248220., 249872., 251524., 253176., 254828., 256480.,
      233170., 234836., 236502., 238168., 239834., 241500., 243166., 244832.,
      246498., 248164., 249830., 251496., 253162., 254828., 256494., 258160.,
      234640., 236320., 238000., 239680., 241360., 243040., 244720., 246400.,
      248080., 249760., 251440., 253120., 254800., 256480., 258160., 259840.};
  const int batches = 1;
  const int m = 16;
  const int k = 14;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK15xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      230525., 232220., 233915., 235610., 237305., 239000., 240695., 242390.,
      244085., 245780., 247475., 249170., 250865., 252560., 232010., 233720.,
      235430., 237140., 238850., 240560., 242270., 243980., 245690., 247400.,
      249110., 250820., 252530., 254240., 233495., 235220., 236945., 238670.,
      240395., 242120., 243845., 245570., 247295., 249020., 250745., 252470.,
      254195., 255920., 234980., 236720., 238460., 240200., 241940., 243680.,
      245420., 247160., 248900., 250640., 252380., 254120., 255860., 257600.,
      236465., 238220., 239975., 241730., 243485., 245240., 246995., 248750.,
      250505., 252260., 254015., 255770., 257525., 259280., 237950., 239720.,
      241490., 243260., 245030., 246800., 248570., 250340., 252110., 253880.,
      255650., 257420., 259190., 260960., 239435., 241220., 243005., 244790.,
      246575., 248360., 250145., 251930., 253715., 255500., 257285., 259070.,
      260855., 262640., 240920., 242720., 244520., 246320., 248120., 249920.,
      251720., 253520., 255320., 257120., 258920., 260720., 262520., 264320.,
      242405., 244220., 246035., 247850., 249665., 251480., 253295., 255110.,
      256925., 258740., 260555., 262370., 264185., 266000., 243890., 245720.,
      247550., 249380., 251210., 253040., 254870., 256700., 258530., 260360.,
      262190., 264020., 265850., 267680., 245375., 247220., 249065., 250910.,
      252755., 254600., 256445., 258290., 260135., 261980., 263825., 265670.,
      267515., 269360., 246860., 248720., 250580., 252440., 254300., 256160.,
      258020., 259880., 261740., 263600., 265460., 267320., 269180., 271040.,
      248345., 250220., 252095., 253970., 255845., 257720., 259595., 261470.,
      263345., 265220., 267095., 268970., 270845., 272720., 249830., 251720.,
      253610., 255500., 257390., 259280., 261170., 263060., 264950., 266840.,
      268730., 270620., 272510., 274400., 251315., 253220., 255125., 257030.,
      258935., 260840., 262745., 264650., 266555., 268460., 270365., 272270.,
      274175., 276080., 252800., 254720., 256640., 258560., 260480., 262400.,
      264320., 266240., 268160., 270080., 272000., 273920., 275840., 277760.};
  const int batches = 1;
  const int m = 16;
  const int k = 15;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK15xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      246870., 248565., 250260., 251955., 253650., 255345., 257040., 258735.,
      260430., 262125., 263820., 265515., 267210., 268905., 270600., 248460.,
      250170., 251880., 253590., 255300., 257010., 258720., 260430., 262140.,
      263850., 265560., 267270., 268980., 270690., 272400., 250050., 251775.,
      253500., 255225., 256950., 258675., 260400., 262125., 263850., 265575.,
      267300., 269025., 270750., 272475., 274200., 251640., 253380., 255120.,
      256860., 258600., 260340., 262080., 263820., 265560., 267300., 269040.,
      270780., 272520., 274260., 276000., 253230., 254985., 256740., 258495.,
      260250., 262005., 263760., 265515., 267270., 269025., 270780., 272535.,
      274290., 276045., 277800., 254820., 256590., 258360., 260130., 261900.,
      263670., 265440., 267210., 268980., 270750., 272520., 274290., 276060.,
      277830., 279600., 256410., 258195., 259980., 261765., 263550., 265335.,
      267120., 268905., 270690., 272475., 274260., 276045., 277830., 279615.,
      281400., 258000., 259800., 261600., 263400., 265200., 267000., 268800.,
      270600., 272400., 274200., 276000., 277800., 279600., 281400., 283200.,
      259590., 261405., 263220., 265035., 266850., 268665., 270480., 272295.,
      274110., 275925., 277740., 279555., 281370., 283185., 285000., 261180.,
      263010., 264840., 266670., 268500., 270330., 272160., 273990., 275820.,
      277650., 279480., 281310., 283140., 284970., 286800., 262770., 264615.,
      266460., 268305., 270150., 271995., 273840., 275685., 277530., 279375.,
      281220., 283065., 284910., 286755., 288600., 264360., 266220., 268080.,
      269940., 271800., 273660., 275520., 277380., 279240., 281100., 282960.,
      284820., 286680., 288540., 290400., 265950., 267825., 269700., 271575.,
      273450., 275325., 277200., 279075., 280950., 282825., 284700., 286575.,
      288450., 290325., 292200., 267540., 269430., 271320., 273210., 275100.,
      276990., 278880., 280770., 282660., 284550., 286440., 288330., 290220.,
      292110., 294000., 269130., 271035., 272940., 274845., 276750., 278655.,
      280560., 282465., 284370., 286275., 288180., 290085., 291990., 293895.,
      295800., 270720., 272640., 274560., 276480., 278400., 280320., 282240.,
      284160., 286080., 288000., 289920., 291840., 293760., 295680., 297600.};
  const int batches = 1;
  const int m = 16;
  const int k = 15;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK15xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      263215., 264910., 266605., 268300., 269995., 271690., 273385., 275080.,
      276775., 278470., 280165., 281860., 283555., 285250., 286945., 288640.,
      264910., 266620., 268330., 270040., 271750., 273460., 275170., 276880.,
      278590., 280300., 282010., 283720., 285430., 287140., 288850., 290560.,
      266605., 268330., 270055., 271780., 273505., 275230., 276955., 278680.,
      280405., 282130., 283855., 285580., 287305., 289030., 290755., 292480.,
      268300., 270040., 271780., 273520., 275260., 277000., 278740., 280480.,
      282220., 283960., 285700., 287440., 289180., 290920., 292660., 294400.,
      269995., 271750., 273505., 275260., 277015., 278770., 280525., 282280.,
      284035., 285790., 287545., 289300., 291055., 292810., 294565., 296320.,
      271690., 273460., 275230., 277000., 278770., 280540., 282310., 284080.,
      285850., 287620., 289390., 291160., 292930., 294700., 296470., 298240.,
      273385., 275170., 276955., 278740., 280525., 282310., 284095., 285880.,
      287665., 289450., 291235., 293020., 294805., 296590., 298375., 300160.,
      275080., 276880., 278680., 280480., 282280., 284080., 285880., 287680.,
      289480., 291280., 293080., 294880., 296680., 298480., 300280., 302080.,
      276775., 278590., 280405., 282220., 284035., 285850., 287665., 289480.,
      291295., 293110., 294925., 296740., 298555., 300370., 302185., 304000.,
      278470., 280300., 282130., 283960., 285790., 287620., 289450., 291280.,
      293110., 294940., 296770., 298600., 300430., 302260., 304090., 305920.,
      280165., 282010., 283855., 285700., 287545., 289390., 291235., 293080.,
      294925., 296770., 298615., 300460., 302305., 304150., 305995., 307840.,
      281860., 283720., 285580., 287440., 289300., 291160., 293020., 294880.,
      296740., 298600., 300460., 302320., 304180., 306040., 307900., 309760.,
      283555., 285430., 287305., 289180., 291055., 292930., 294805., 296680.,
      298555., 300430., 302305., 304180., 306055., 307930., 309805., 311680.,
      285250., 287140., 289030., 290920., 292810., 294700., 296590., 298480.,
      300370., 302260., 304150., 306040., 307930., 309820., 311710., 313600.,
      286945., 288850., 290755., 292660., 294565., 296470., 298375., 300280.,
      302185., 304090., 305995., 307900., 309805., 311710., 313615., 315520.,
      288640., 290560., 292480., 294400., 296320., 298240., 300160., 302080.,
      304000., 305920., 307840., 309760., 311680., 313600., 315520., 317440.};
  const int batches = 1;
  const int m = 16;
  const int k = 15;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK16xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      281376., 283312., 285248., 287184., 289120., 291056., 292992., 294928.,
      296864., 298800., 300736., 302672., 304608., 306544., 283072., 285024.,
      286976., 288928., 290880., 292832., 294784., 296736., 298688., 300640.,
      302592., 304544., 306496., 308448., 284768., 286736., 288704., 290672.,
      292640., 294608., 296576., 298544., 300512., 302480., 304448., 306416.,
      308384., 310352., 286464., 288448., 290432., 292416., 294400., 296384.,
      298368., 300352., 302336., 304320., 306304., 308288., 310272., 312256.,
      288160., 290160., 292160., 294160., 296160., 298160., 300160., 302160.,
      304160., 306160., 308160., 310160., 312160., 314160., 289856., 291872.,
      293888., 295904., 297920., 299936., 301952., 303968., 305984., 308000.,
      310016., 312032., 314048., 316064., 291552., 293584., 295616., 297648.,
      299680., 301712., 303744., 305776., 307808., 309840., 311872., 313904.,
      315936., 317968., 293248., 295296., 297344., 299392., 301440., 303488.,
      305536., 307584., 309632., 311680., 313728., 315776., 317824., 319872.,
      294944., 297008., 299072., 301136., 303200., 305264., 307328., 309392.,
      311456., 313520., 315584., 317648., 319712., 321776., 296640., 298720.,
      300800., 302880., 304960., 307040., 309120., 311200., 313280., 315360.,
      317440., 319520., 321600., 323680., 298336., 300432., 302528., 304624.,
      306720., 308816., 310912., 313008., 315104., 317200., 319296., 321392.,
      323488., 325584., 300032., 302144., 304256., 306368., 308480., 310592.,
      312704., 314816., 316928., 319040., 321152., 323264., 325376., 327488.,
      301728., 303856., 305984., 308112., 310240., 312368., 314496., 316624.,
      318752., 320880., 323008., 325136., 327264., 329392., 303424., 305568.,
      307712., 309856., 312000., 314144., 316288., 318432., 320576., 322720.,
      324864., 327008., 329152., 331296., 305120., 307280., 309440., 311600.,
      313760., 315920., 318080., 320240., 322400., 324560., 326720., 328880.,
      331040., 333200., 306816., 308992., 311168., 313344., 315520., 317696.,
      319872., 322048., 324224., 326400., 328576., 330752., 332928., 335104.};
  const int batches = 1;
  const int m = 16;
  const int k = 16;
  const int n = 14;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK16xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      301336., 303272., 305208., 307144., 309080., 311016., 312952., 314888.,
      316824., 318760., 320696., 322632., 324568., 326504., 328440., 303152.,
      305104., 307056., 309008., 310960., 312912., 314864., 316816., 318768.,
      320720., 322672., 324624., 326576., 328528., 330480., 304968., 306936.,
      308904., 310872., 312840., 314808., 316776., 318744., 320712., 322680.,
      324648., 326616., 328584., 330552., 332520., 306784., 308768., 310752.,
      312736., 314720., 316704., 318688., 320672., 322656., 324640., 326624.,
      328608., 330592., 332576., 334560., 308600., 310600., 312600., 314600.,
      316600., 318600., 320600., 322600., 324600., 326600., 328600., 330600.,
      332600., 334600., 336600., 310416., 312432., 314448., 316464., 318480.,
      320496., 322512., 324528., 326544., 328560., 330576., 332592., 334608.,
      336624., 338640., 312232., 314264., 316296., 318328., 320360., 322392.,
      324424., 326456., 328488., 330520., 332552., 334584., 336616., 338648.,
      340680., 314048., 316096., 318144., 320192., 322240., 324288., 326336.,
      328384., 330432., 332480., 334528., 336576., 338624., 340672., 342720.,
      315864., 317928., 319992., 322056., 324120., 326184., 328248., 330312.,
      332376., 334440., 336504., 338568., 340632., 342696., 344760., 317680.,
      319760., 321840., 323920., 326000., 328080., 330160., 332240., 334320.,
      336400., 338480., 340560., 342640., 344720., 346800., 319496., 321592.,
      323688., 325784., 327880., 329976., 332072., 334168., 336264., 338360.,
      340456., 342552., 344648., 346744., 348840., 321312., 323424., 325536.,
      327648., 329760., 331872., 333984., 336096., 338208., 340320., 342432.,
      344544., 346656., 348768., 350880., 323128., 325256., 327384., 329512.,
      331640., 333768., 335896., 338024., 340152., 342280., 344408., 346536.,
      348664., 350792., 352920., 324944., 327088., 329232., 331376., 333520.,
      335664., 337808., 339952., 342096., 344240., 346384., 348528., 350672.,
      352816., 354960., 326760., 328920., 331080., 333240., 335400., 337560.,
      339720., 341880., 344040., 346200., 348360., 350520., 352680., 354840.,
      357000., 328576., 330752., 332928., 335104., 337280., 339456., 341632.,
      343808., 345984., 348160., 350336., 352512., 354688., 356864., 359040.};
  const int batches = 1;
  const int m = 16;
  const int k = 16;
  const int n = 15;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta0TrueFalse, M16xK16xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      321296., 323232., 325168., 327104., 329040., 330976., 332912., 334848.,
      336784., 338720., 340656., 342592., 344528., 346464., 348400., 350336.,
      323232., 325184., 327136., 329088., 331040., 332992., 334944., 336896.,
      338848., 340800., 342752., 344704., 346656., 348608., 350560., 352512.,
      325168., 327136., 329104., 331072., 333040., 335008., 336976., 338944.,
      340912., 342880., 344848., 346816., 348784., 350752., 352720., 354688.,
      327104., 329088., 331072., 333056., 335040., 337024., 339008., 340992.,
      342976., 344960., 346944., 348928., 350912., 352896., 354880., 356864.,
      329040., 331040., 333040., 335040., 337040., 339040., 341040., 343040.,
      345040., 347040., 349040., 351040., 353040., 355040., 357040., 359040.,
      330976., 332992., 335008., 337024., 339040., 341056., 343072., 345088.,
      347104., 349120., 351136., 353152., 355168., 357184., 359200., 361216.,
      332912., 334944., 336976., 339008., 341040., 343072., 345104., 347136.,
      349168., 351200., 353232., 355264., 357296., 359328., 361360., 363392.,
      334848., 336896., 338944., 340992., 343040., 345088., 347136., 349184.,
      351232., 353280., 355328., 357376., 359424., 361472., 363520., 365568.,
      336784., 338848., 340912., 342976., 345040., 347104., 349168., 351232.,
      353296., 355360., 357424., 359488., 361552., 363616., 365680., 367744.,
      338720., 340800., 342880., 344960., 347040., 349120., 351200., 353280.,
      355360., 357440., 359520., 361600., 363680., 365760., 367840., 369920.,
      340656., 342752., 344848., 346944., 349040., 351136., 353232., 355328.,
      357424., 359520., 361616., 363712., 365808., 367904., 370000., 372096.,
      342592., 344704., 346816., 348928., 351040., 353152., 355264., 357376.,
      359488., 361600., 363712., 365824., 367936., 370048., 372160., 374272.,
      344528., 346656., 348784., 350912., 353040., 355168., 357296., 359424.,
      361552., 363680., 365808., 367936., 370064., 372192., 374320., 376448.,
      346464., 348608., 350752., 352896., 355040., 357184., 359328., 361472.,
      363616., 365760., 367904., 370048., 372192., 374336., 376480., 378624.,
      348400., 350560., 352720., 354880., 357040., 359200., 361360., 363520.,
      365680., 367840., 370000., 372160., 374320., 376480., 378640., 380800.,
      350336., 352512., 354688., 356864., 359040., 361216., 363392., 365568.,
      367744., 369920., 372096., 374272., 376448., 378624., 380800., 382976.};
  const int batches = 1;
  const int m = 16;
  const int k = 16;
  const int n = 16;
  const auto beta = static_cast<DataType>(0);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}